/*
 * ProtocoloCliente.cpp
 *
 * Author: Grupo Nro.
 */

#include "ProtocoloCliente.h"

ProtocoloCliente::ProtocoloCliente() {
}

ProtocoloCliente::~ProtocoloCliente() {
}

string ProtocoloCliente::formatearLongitud(string & longitud){
	if (longitud.length() < CANT_BYTES_TAMANIO){
		string cadena = "";
		string cero = "0";
		int faltante = CANT_BYTES_TAMANIO - longitud.length();
		int i = 0;
		while (i < faltante){
			cadena.append(cero.c_str());
			i++;
		}
		cadena.append(longitud);
		return cadena;
	}

	return longitud;
}

string ProtocoloCliente::armarPrimerMensaje(string & codigoMensaje,
		long longitud){
	//Me aseguro que la longitud del codigo de mensaje sea la correcta
	if (codigoMensaje.length() != CANT_BYTES_CODIGO){
		string mensajeError = "Error en el código del mensaje que se intentar usar. Código:";
		mensajeError.append(codigoMensaje.c_str());
		throw ComunicacionException(mensajeError);
	}

	//Verifico longitud del mensaje
	string numeroCadena = Utils::pasarLongACadena(longitud);
	if (numeroCadena.length() > CANT_BYTES_TAMANIO){
		string mensajeError = "Error - mensaje mas largo de lo permitido. Longitud:";
		mensajeError.append(numeroCadena.c_str());
		throw ComunicacionException(mensajeError);
	}

	string longOk = formatearLongitud(numeroCadena);
	string mensaje = codigoMensaje;
	mensaje.append(longOk.c_str());
	if (mensaje.length() != (CANT_BYTES_PRIMER_MENSAJE - 1)){
		string mensajeError = "Error al formar el mensaje. Mensaje:";
		mensajeError.append(mensaje.c_str());
		throw ComunicacionException(mensajeError);
	}

	string finCadena = "\0";
	mensaje.append(finCadena.c_str());
	return mensaje;
}

bool ProtocoloCliente::enviarMensaje(int sockfd, string & codigoMensaje,
		string & mensaje){
	try {
		long longitud = mensaje.length();
		string primerMensaje = armarPrimerMensaje(codigoMensaje, longitud);

		if (!Protocolo::sendAll(sockfd, primerMensaje)){
			string mensajeError = "Error al enviar el primer mensaje con código:";
			mensajeError.append(codigoMensaje.c_str());
			throw ComunicacionException(mensajeError);
		}

		if (longitud != 0){
			if (!Protocolo::sendAll(sockfd, mensaje)){
				string mensajeError = "Error al enviar el segundo mensaje para código de mensaje:";
				mensajeError.append(codigoMensaje.c_str());
				throw ComunicacionException(mensajeError);
			}
		}

	} catch (ComunicacionException & e) {
		cerr << e.error() << std::endl;
		throw e;
	}

	return true;
}

/*
 * Se envia la opcion seleccionada por el usuario,
 * 			- si crea partida (mensaje=1)
 * 			- se une a una existente (mensaje=0)
 *
 * @ param sockfd
 * 		Descriptor del socket al que se le va a enviar datos (servidor).
 * @ param campanias
 * 		Campanias dentro del juego.
 *
 * @ mensajeEnviado
 * 		Si crea partida, mensaje:1
 * 		Si se une a partida existente, mensaje:0
 *
 * @ return
 * 		True si pudo enviar el mensaje completamente. Caso contrario, false.
 */
bool ProtocoloCliente::send_opcionSeleccionadaInicial(int sockfd,
		bool creaPartida){
	string mensaje = "0";
	if (creaPartida){
		mensaje = "1";
	}

	//Agrego fin de cadena
	string finCadena = "\0";
	mensaje.append(finCadena.c_str());

	string codigoMensaje = CP;
	return enviarMensaje(sockfd, codigoMensaje, mensaje);
}

/*
 * Recibe las campanias existentes en el juego.
 *
 * @ param sockfd
 * 		Descriptor del socket del que se va a leer (servidor).
 *
 * @ return mensaje:
 * 		<Id de la campania>\t<Nombre de la campania>\t<Imagen>|...|<Id de la
 * 		campania>\t<Nombre de la campania>\t<Imagen>
 * TODO TODAVIA NO SE ENVIA LA IMAGEN EN ESTE MENSAJE
 */
string ProtocoloCliente::recv_campaniasExistentes(int sockfd){
	string mensaje = "";
	string codigoMensaje = "";
	if (!Protocolo::recvAll(sockfd, mensaje, codigoMensaje)){
		throw (ComunicacionException(Protocolo::mensajeErrorMensajeInicial(sockfd)));
	}

	if (codigoMensaje.compare((string(CE)).c_str()) != 0){
		throw ComunicacionException(Protocolo::mensajeErrorCodigo(codigoMensaje, sockfd));
	}

	return mensaje;
}

/*
 * Se envia la campania seleccionada y el nombre de la partida que desea
 * crear dentro de dicha campania.
 *
 * @ param sockfd
 * 		Descriptor del socket al que se le va a enviar datos (servidor).
 * @ param idCampania
 * 		Id de la Campania seleccionada.
 * @ param nombrePartida
 * 		Nombre para la nueva partida.
 *
 * @ mensajeEnviado:
 * 		<id de la campania seleccionada>|<nombre nueva partida>
 *
 * @ return
 * 		True si pudo enviar el mensaje completamente. Caso contrario, false.
 */
bool ProtocoloCliente::send_campaniaSeleccionadaYnombrePartida(int sockfd,
		string & idCampania, string & nombrePartida){
	//Id campania
	string mensaje = idCampania;
	//Separador
	mensaje.append((string(SEPARADOR_DATOS)).c_str());
	//Nombre partida
	mensaje.append(nombrePartida.c_str());
	//Agrego fin de cadena
	string finCadena = "\0";
	mensaje.append(finCadena.c_str());

	string codigoMensaje = CN;
	return enviarMensaje(sockfd, codigoMensaje, mensaje);
}

/*
 * Recibe las partidas todavia no comenzadas que existen.
 *
 * @ param sockfd
 * 		Descriptor del socket del que se va a leer (servidor).
 *
 * @ return mensaje:
 * 		<Id partida>\t<Nombre partida>\t<Id campania>\t<Nombre
 * 		campania>\t<Imagen>|...|<Id partida>\t<Nombre partida>\t<Id
 * 		campania>\t<Nombre campania>\t<Imagen>
 * TODO TODAVIA NO SE ENVIA IMAGEN
 */
string ProtocoloCliente::recv_partidasExistentesNoComenzadas(int sockfd){
	string mensaje = "";
	string codigoMensaje = "";
	if (!Protocolo::recvAll(sockfd, mensaje, codigoMensaje)){
		throw ComunicacionException(Protocolo::mensajeErrorMensajeInicial(sockfd));
	}

	if (codigoMensaje.compare((string(PE)).c_str()) != 0){
		throw ComunicacionException(Protocolo::mensajeErrorCodigo(codigoMensaje, sockfd));
	}

	return mensaje;
}

/*
 * Se envia la partida seleccionada a la cual se va a asociar el jugador.
 *
 * @ param sockfd
 * 		Descriptor del socket del que se va a leer (servidor).
 * @ param idPartida
 * 		Id de la partida a la cual se va a asociar.
 *
 * @ mensajeEnviado
 * 		<id de la partida seleccionada>
 *
 * @ return
 * 		True si pudo enviar el mensaje completamente. Caso contrario, false.
 */
bool ProtocoloCliente::send_partidaSeleccionada(int sockfd, string & idPartida){
	//Id partida
	string mensaje = idPartida;
	//Agrego fin de cadena
	string finCadena = "\0";
	mensaje.append(finCadena.c_str());

	string codigoMensaje = PS;
	return enviarMensaje(sockfd, codigoMensaje, mensaje);
}

/*
 * Se le informa que la partida esta en condiciones de ser comenzada:
 * tiene los jugadores minimos requeridos para poder comenzar.
 *
 * @ param sockfd
 * 		Descriptor del socket del que se va a leer (servidor).
 *
 * @ return mensaje:
 * 		<Id partida>|<Nombre partida>
 */
string ProtocoloCliente::recv_partidaListaParaComenzar(int sockfd){
	string mensaje = "";
	string codigoMensaje = "";
	if (!Protocolo::recvAll(sockfd, mensaje, codigoMensaje)){
		throw ComunicacionException(Protocolo::mensajeErrorMensajeInicial(sockfd));
	}

	if (codigoMensaje.compare((string(PC)).c_str()) != 0){
		throw ComunicacionException(Protocolo::mensajeErrorCodigo(codigoMensaje, sockfd));
	}

	return mensaje;
}

/*
 * Se envia la decision de iniciar o no una partida.
 *
 * @ param sockfd
 * 		Descriptor del socket del que se va a leer (servidor).
 * @ param comenzar
 * 		True: se quiere comenzar la partida.
 * 		False: no se quiere comenzar la partida todavia.
 *
 * @ mensajeEnviar
 * 		Se p0ueden venir uno de los siguientes mensajes:
 * 		True: 1|<id de la parida a comenzar>
 * 		False: 0
 *
 * 		1: se quiere comenzar la partida
 * 		0: no se quiere comenzar la partida todavia
 *
 * @ return
 * 		True si pudo enviar el mensaje completamente. Caso contrario, false.
 */
bool ProtocoloCliente::send_comenzarPartida(int sockfd, bool comenzar,
		string & idPartida){
	string mensaje = "";

	if (comenzar){
		mensaje.append((string("1")).c_str());
		mensaje.append((string(SEPARADOR_DATOS)).c_str()); //Separador
		mensaje.append(idPartida.c_str());
	} else {
		mensaje.append((string("0")).c_str());
	}

	//Agrego fin de cadena
	string finCadena = "\0";
	mensaje.append(finCadena.c_str());

	string codigoMensaje = CO;
	return enviarMensaje(sockfd, codigoMensaje, mensaje);
}

/*
 * Recibe la noticia de que la partida fue iniciada.
 *
 * @ param sockfd
 * 		Descriptor del socket del que se va a leer (servidor).
 *
 * @ return mensaje:
 * 		<Id partida>|<Nombre partida>
 */
string ProtocoloCliente::recv_partidaIniciada(int sockfd){
	string mensaje = "";
	string codigoMensaje = "";
	if (!Protocolo::recvAll(sockfd, mensaje, codigoMensaje)){
		throw ComunicacionException(Protocolo::mensajeErrorMensajeInicial(sockfd));
	}

	if (codigoMensaje.compare((string(PI)).c_str()) != 0){
		throw ComunicacionException(Protocolo::mensajeErrorCodigo(codigoMensaje, sockfd));
	}

	return mensaje;
}

/*
 * Se reciben las dimensiones que posee el escenario sobre
 * el cual se va a desarrollar la partida.
 *
 * @ param sockfd
 * 		Descriptor del socket del que se va a leer (servidor).
 *
 * @ retunr mensaje
 * 		<Cantidad filas>|<Cantidad columnas>
 */
string ProtocoloCliente::recv_dimensionEscenario(int sockfd){
	string mensaje = "";
	string codigoMensaje = "";
	if (!Protocolo::recvAll(sockfd, mensaje, codigoMensaje)){
		throw ComunicacionException(Protocolo::mensajeErrorMensajeInicial(sockfd));
	}

	if (codigoMensaje.compare((string(DE)).c_str()) != 0){
		throw ComunicacionException(Protocolo::mensajeErrorCodigo(codigoMensaje, sockfd));
	}

	return mensaje;
}

/*
 * Se envian las coordenadas del escenario que le interesa al jugador.
 *
 * @ param sockfd
 * 		Descriptor del socket del que se va a leer (servidor).
 * @ param filaDesde
 * 		Fila desde la cual le interesa tener informacion.
 * @ param filaHasta
 * 		Fila hasta la cual le interesa tener informacion.
 * @ param columnaDesde
 * 		Columna desde la cual le interesa tener informacion.
 * @ param columnaHasta
 * 		Columna hasta la cual le interesa tener informacion.
 *
 * @ mensajeEnviado
 * 		<Nro Fila Desde>|<Nro Fila Hasta>|<Nro Columna Desde>|<Nro Columna
 * 		Hasta>
 *
 * @ return
 * 		True si pudo enviar el mensaje completamente. Caso contrario, false.
 */
bool ProtocoloCliente::send_coordenadasEscenarioInteresa(int sockfd,
		long filaDesde, long filaHasta, long columnaDesde, long columnaHasta){
	string mensaje = "";

	//Fila desde
	string numeroCadena = Utils::pasarLongACadena(filaDesde);
	mensaje.append(numeroCadena.c_str());
	mensaje.append((string(SEPARADOR_DATOS)).c_str()); //Separador

	//Fila hasta
	numeroCadena = Utils::pasarLongACadena(filaHasta);
	mensaje.append(numeroCadena.c_str());
	mensaje.append((string(SEPARADOR_DATOS)).c_str()); //Separador

	//Columna desde
	numeroCadena = Utils::pasarLongACadena(columnaDesde);
	mensaje.append(numeroCadena.c_str());
	mensaje.append((string(SEPARADOR_DATOS)).c_str()); //Separador

	//Columna hasta
	numeroCadena = Utils::pasarLongACadena(columnaHasta);
	mensaje.append(numeroCadena.c_str());

	//Agrego fin de cadena
	string finCadena = "\0";
	mensaje.append(finCadena.c_str());

	string codigoMensaje = EI;
	return enviarMensaje(sockfd, codigoMensaje, mensaje);
}

/*
 * Se recibe la parte del escenario que le interesa al cliente.
 *
 * @ param sockfd
 * 		Descriptor del socket del que se va a leer (servidor).
 *
 * @ return mensaje
 * 		<Contenido celda M>|<Contenido celda M+1>|...|<Contenido celda N>
 * 		Se informa cada celda de la matriz, recorrida esta de arriba hacia
 * 		abajo y de izquierda a derecha.
 */
string ProtocoloCliente::recv_escenarioInteresJugador(int sockfd){
	string mensaje = "";
	string codigoMensaje = "";
	if (!Protocolo::recvAll(sockfd, mensaje, codigoMensaje)){
		throw ComunicacionException(Protocolo::mensajeErrorMensajeInicial(sockfd));
	}

	if (codigoMensaje.compare((string(EJ)).c_str()) != 0){
		throw ComunicacionException(Protocolo::mensajeErrorCodigo(codigoMensaje, sockfd));
	}

	return mensaje;
}

/*
 * Se recibe informacion del puntaje de un jugador.
 *
 * @ param sockfd
 * 		Descriptor del socket del que se va a leer (servidor).
 *
 * @ return mensaje
 *    <Id del jugador>|<Nombre del jugador>|<Puntaje>
 */
string ProtocoloCliente::recv_puntajeYjugador(int sockfd){
	string mensaje = "";
	string codigoMensaje = "";
	if (!Protocolo::recvAll(sockfd, mensaje, codigoMensaje)){
		throw ComunicacionException(Protocolo::mensajeErrorMensajeInicial(sockfd));
	}

	if (codigoMensaje.compare((string(JP)).c_str()) != 0){
		throw ComunicacionException(Protocolo::mensajeErrorCodigo(codigoMensaje, sockfd));
	}

	return mensaje;
}

/*
 * Recibe la noticia del fin de un partida
 *
 * @ param sockfd
 * 		Descriptor del socket del que se va a leer (servidor).
 *
 * @ return mensaje
 *    <Id de la partida>|<Nombre de la partida>
 */
string ProtocoloCliente::recv_finPartida(int sockfd){
	string mensaje = "";
	string codigoMensaje = "";
	if (!Protocolo::recvAll(sockfd, mensaje, codigoMensaje)){
		throw ComunicacionException(Protocolo::mensajeErrorMensajeInicial(sockfd));
	}

	if (codigoMensaje.compare((string(FP)).c_str()) != 0){
		throw ComunicacionException(Protocolo::mensajeErrorCodigo(codigoMensaje, sockfd));
	}

	return mensaje;
}

/*
 * Recibe la noticia de la explosion de una bomba.
 *
 * @ param sockfd
 * 		Descriptor del socket del que se va a leer (servidor).
 *
 * @ return
 * 		True si recibio realmente la noticia de la
 * 		explosion. Caso contrario, false.
 */
bool ProtocoloCliente::recv_explosionBomba(int sockfd){
	string mensaje = "";
	string codigoMensaje = "";
	if (!Protocolo::recvAll(sockfd, mensaje, codigoMensaje)){
		throw ComunicacionException(Protocolo::mensajeErrorMensajeInicial(sockfd));
	}

	if (codigoMensaje.compare((string(EB)).c_str()) != 0){
		return false;
	}

	return true;
}

/*
 * Recibe la noticia de que un jugador fue destruido.
 *
 * @ param sockfd
 * 		Descriptor del socket del que se va a leer (servidor).
 *
 * @ return mensaje
 *      <id del bomberman>|<nombre>
 */
string ProtocoloCliente::recv_bombermanDestruido(int sockfd){
	string mensaje = "";
	string codigoMensaje = "";
	if (!Protocolo::recvAll(sockfd, mensaje, codigoMensaje)){
		throw ComunicacionException(Protocolo::mensajeErrorMensajeInicial(sockfd));
	}

	if (codigoMensaje.compare((string(BD)).c_str()) != 0){
		throw ComunicacionException(Protocolo::mensajeErrorCodigo(codigoMensaje, sockfd));
	}

	return mensaje;
}

/*
 * Recibe la noticia de que un zombie ha sido destruido.
 *
 * @ param sockfd
 * 		Descriptor del socket del que se va a leer (servidor).
 *
 * @ return
 * 		True si recibio realmente la noticia de la destruccion de un zombie.
 * 		Caso contrario, false.
 */
bool ProtocoloCliente::recv_zombieDestruido(int sockfd){
	string mensaje = "";
	string codigoMensaje = "";
	if (!Protocolo::recvAll(sockfd, mensaje, codigoMensaje)){
		throw ComunicacionException(Protocolo::mensajeErrorMensajeInicial(sockfd));
	}

	if (codigoMensaje.compare((string(ZD)).c_str()) != 0){
		return false;
	}

	return true;
}

/*
 * Recibe la noticia de que una planta ha lanzado una bomba.
 *
 * @ param sockfd
 * 		Descriptor del socket del que se va a leer (servidor).
 *
 * @ return
 * 		True si recibio realmente la noticia de que una bomba ha sido lanzada
 * 		por una planta. Caso contrario, false.
 */
bool ProtocoloCliente::recv_bombaLanzadaPlanta(int sockfd){
	string mensaje = "";
	string codigoMensaje = "";
	if (!Protocolo::recvAll(sockfd, mensaje, codigoMensaje)){
		throw ComunicacionException(Protocolo::mensajeErrorMensajeInicial(sockfd));
	}

	if (codigoMensaje.compare((string(BP)).c_str()) != 0){
		return false;
	}

	return true;
}

/*
 * Se envia informacion de que un donde se genera una bomba.
 *
 * @ param sockfd
 * 		Descriptor del socket del que se va a leer (servidor).
 *
 * @ mensajeEnviado
 * 		<Fila donde se genero bomba>|<Columna donde se genero bomba>
 *
 * @ return
 * 		True si pudo enviar el mensaje completamente. Caso contrario, false.
 */
bool ProtocoloCliente::send_bombaGeneradaBomberman(int sockfd, long fila,
		long columna){
	string mensaje = "";

	//Fila
	string numeroCadena = Utils::pasarLongACadena(fila);
	mensaje.append(numeroCadena.c_str());
	mensaje.append((string(SEPARADOR_DATOS)).c_str()); //Separador

	//Columna
	numeroCadena = Utils::pasarLongACadena(columna);
	mensaje.append(numeroCadena.c_str());

	//Agrego fin de cadena
	string finCadena = "\0";
	mensaje.append(finCadena.c_str());

	string codigoMensaje = BB;
	return enviarMensaje(sockfd, codigoMensaje, mensaje);
}

/*
 * Recibe la informacion de que han generado un bomba.
 *
 * @ param sockfdCliente
 * 		Descriptor del socket del que se va a leer (cliente = jugador).
 *
 * @ return
 * 		Mensaje:
 * 		<Fila donde se genero bomba>|<Columna donde se genero bomba>
 */
string ProtocoloCliente::recv_bombaGeneradaBomberman(int sockfd){
	string mensaje = "";
	string codigoMensaje = "";
	if (!Protocolo::recvAll(sockfd, mensaje, codigoMensaje)){
		throw ComunicacionException(Protocolo::mensajeErrorMensajeInicial(sockfd));
	}

	if (codigoMensaje.compare((string(BB)).c_str()) != 0){
		throw ComunicacionException(Protocolo::mensajeErrorCodigo(codigoMensaje, sockfd));
	}

	return mensaje;
}

/*
 * Recibe la noticia de que un nuevo bomberman se ha unido a la partida.
 *
 * @ param sockfd
 * 		Descriptor del socket del que se va a leer (cliente = jugador).
 *
 * @ return mensaje
 * 		<Id partida>|<Nombre partida>
 */
string ProtocoloCliente::recv_nuevoBomberman(int sockfd){
	string mensaje = "";
	string codigoMensaje = "";
	if (!Protocolo::recvAll(sockfd, mensaje, codigoMensaje)){
		throw ComunicacionException(Protocolo::mensajeErrorMensajeInicial(sockfd));
	}

	if (codigoMensaje.compare((string(NB)).c_str()) != 0){
		throw ComunicacionException(Protocolo::mensajeErrorCodigo(codigoMensaje, sockfd));
	}

	return mensaje;
}

/*
 * Se envia movimiento del jugador.
 *
 * @ param sockfd
 * 		Descriptor del socket del que se va a leer (cliente = jugador).
 *
 * @ mensajeEnviado
 * 		<Alguno de los siguientes movimientos: UP, RIGHT, DOWN, LEFT>
 *
 * @ return
 * 		True si pudo enviar el mensaje completamente. Caso contrario, false.
 */
bool ProtocoloCliente::send_movimientoJugador(int sockfd, string movimiento){
	string mensaje = movimiento;

	//Agrego fin de cadena
	string finCadena = "\0";
	mensaje.append(finCadena.c_str());

	string codigoMensaje = MO;
	return enviarMensaje(sockfd, codigoMensaje, mensaje);
}

/*
 * Se envia una solicitud de cambios al servidor.
 *
 * @ param sockfd
 * 		Descriptor del socket al cual se le envia mensaje (servidor).
 *
 * @ return
 * 		True si pudo enviar el mensaje completamente. Caso contrario, false.
 */
bool ProtocoloCliente::send_requestForUpdates(int sockfd){
	 string mensaje = "";

	string codigoMensaje = RU;
	return enviarMensaje(sockfd, codigoMensaje, mensaje);
}

string ProtocoloCliente::recv_updates(int sockfd){
	string mensaje = "";
	string codigoMensaje = "";
	if (!Protocolo::recvAll(sockfd, mensaje, codigoMensaje)){
		throw ComunicacionException(Protocolo::mensajeErrorMensajeInicial(sockfd));
	}
	return mensaje;
}

string ProtocoloCliente::recv_scenario(int sockfd){
	string mensaje = "";
	string codigoMensaje = "";
	if (!Protocolo::recvAll(sockfd, mensaje, codigoMensaje)){
		throw ComunicacionException(Protocolo::mensajeErrorMensajeInicial(sockfd));
	}

	if (codigoMensaje.compare((string(RS)).c_str()) != 0){
		throw ComunicacionException(Protocolo::mensajeErrorCodigo(codigoMensaje, sockfd));
	}
	return mensaje;
}

bool ProtocoloCliente::send_update(int sockfd, std::string& updates){

	//Agrego fin de cadena
	string finCadena = "\0";
	updates.append(finCadena.c_str());

	string codigoMensaje = RU;
	return enviarMensaje(sockfd, codigoMensaje, updates);
}

/*
 * Recibe las updates del servidor, si las hubiera.
 *
 * @ param sockfd
 * 		Descriptor del socket al cual se le envia mensaje (servidor).
 *
 * @ return mensaje
 * 		<mensaje con las actualizaciones>
 */
string ProtocoloCliente::recv_requestForUpdates(int sockfd){
	string mensaje = "";
	string codigoMensaje = "";
	if (!Protocolo::recvAll(sockfd, mensaje, codigoMensaje)){
		throw ComunicacionException(Protocolo::mensajeErrorMensajeInicial(sockfd));
	}

	if (codigoMensaje.compare((string(RU)).c_str()) != 0){
		throw ComunicacionException(Protocolo::mensajeErrorCodigo(codigoMensaje, sockfd));
	}

	return mensaje;
}

//TODO Eliminar es un mensaje de prueba
string ProtocoloCliente::recv_mensajeBienvenida(int sockfd){
	string mensaje = "";
	string codigoMensaje = "";
	if (!Protocolo::recvAll(sockfd, mensaje, codigoMensaje)){
		string mensajeError = "No se puede recibir mensaje inicial para tener cliente ok. Sockfd:";
		mensajeError.append(Utils::pasarLongACadena(sockfd));
		cerr << mensajeError << std::endl;
		/*throw ComunicacionException("No se puede recibir mensaje inicial "
				+ "para tener cliente ok. Sockfd:" + sockfdCliente);*/
	}

	if (codigoMensaje.compare((string("BI")).c_str()) != 0){
		string mensajeError = "Error en el código del mensaje recibo. Codigo recibido:";
		mensajeError.append(codigoMensaje.c_str());
		mensajeError.append(". Sockfd:");
		mensajeError.append(Utils::pasarLongACadena(sockfd));
		cerr << mensajeError << std::endl;
		/*throw ComunicacionException("Error en el código del mensaje recibo. "
				+ "Codigo recibido:" + codigoMensaje
				+ ". Sockfd:" + sockfdCliente);*/
	}

	std::cout << "Mensaje de bienvenida:" << mensaje << std::endl;

	return mensaje;
}

bool ProtocoloCliente::send_mensajeAgradecimiento(int sockfd){
	//Id de la partida y su nombre
	string mensaje = "GRACIAS";

	//Agrego fin de cadena
	string finCadena = "\0";
	mensaje.append(finCadena.c_str());

	string codigoMensaje = "AG";
	std::cout << "Va a enviar mensaje de agradecimiento:" << mensaje << std::endl;
	return enviarMensaje(sockfd, codigoMensaje, mensaje);
}
//FIN TODO
